// Machine generated IDispatch wrapper class(es) created with ClassWizard

#include "stdafx.h"
#include "sapi.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif



/////////////////////////////////////////////////////////////////////////////
// ISpeechDataKey properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechDataKey operations

void ISpeechDataKey::SetBinaryValue(LPCTSTR ValueName, const VARIANT& Value)
{
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ValueName, &Value);
}

VARIANT ISpeechDataKey::GetBinaryValue(LPCTSTR ValueName)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		ValueName);
	return result;
}

void ISpeechDataKey::SetStringValue(LPCTSTR ValueName, LPCTSTR Value)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ValueName, Value);
}

CString ISpeechDataKey::GetStringValue(LPCTSTR ValueName)
{
	CString result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		ValueName);
	return result;
}

void ISpeechDataKey::SetLongValue(LPCTSTR ValueName, long Value)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ValueName, Value);
}

long ISpeechDataKey::GetLongValue(LPCTSTR ValueName)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		ValueName);
	return result;
}

LPDISPATCH ISpeechDataKey::OpenKey(LPCTSTR SubKeyName)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		SubKeyName);
	return result;
}

LPDISPATCH ISpeechDataKey::CreateKey(LPCTSTR SubKeyName)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		SubKeyName);
	return result;
}

void ISpeechDataKey::DeleteKey(LPCTSTR SubKeyName)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 SubKeyName);
}

void ISpeechDataKey::DeleteValue(LPCTSTR ValueName)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ValueName);
}

CString ISpeechDataKey::EnumKeys(long Index)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Index);
	return result;
}

CString ISpeechDataKey::EnumValues(long Index)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectToken properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectToken operations

CString ISpeechObjectToken::GetId()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechObjectToken::GetCategory()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString ISpeechObjectToken::GetDescription(long Locale)
{
	CString result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		Locale);
	return result;
}

CString ISpeechObjectToken::GetAttribute(LPCTSTR AttributeName)
{
	CString result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		AttributeName);
	return result;
}

LPUNKNOWN ISpeechObjectToken::CreateInstance(LPUNKNOWN pUnkOuter, long ClsContext)
{
	LPUNKNOWN result;
	static BYTE parms[] =
		VTS_UNKNOWN VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_UNKNOWN, (void*)&result, parms,
		pUnkOuter, ClsContext);
	return result;
}

BOOL ISpeechObjectToken::MatchesAttributes(LPCTSTR Attributes)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Attributes);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokenCategory properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokenCategory operations

CString ISpeechObjectTokenCategory::GetId()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void ISpeechObjectTokenCategory::SetDefault(LPCTSTR lpszNewValue)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 lpszNewValue);
}

CString ISpeechObjectTokenCategory::GetDefault()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void ISpeechObjectTokenCategory::SetId(LPCTSTR Id, BOOL CreateIfNotExist)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BOOL;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Id, CreateIfNotExist);
}

LPDISPATCH ISpeechObjectTokenCategory::EnumerateTokens(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokens properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechObjectTokens operations

long ISpeechObjectTokens::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechObjectTokens::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioBufferInfo properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioBufferInfo operations

long ISpeechAudioBufferInfo::GetMinNotification()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechAudioBufferInfo::SetMinNotification(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechAudioBufferInfo::GetBufferSize()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechAudioBufferInfo::SetBufferSize(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechAudioBufferInfo::GetEventBias()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechAudioBufferInfo::SetEventBias(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioStatus properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioStatus operations

long ISpeechAudioStatus::GetFreeBufferSpace()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechAudioStatus::GetNonBlockingIO()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechAudioStatus::GetState()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechAudioStatus::GetCurrentSeekPosition()
{
	VARIANT result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechAudioStatus::GetCurrentDevicePosition()
{
	VARIANT result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioFormat properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechAudioFormat operations

long ISpeechAudioFormat::GetType()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechAudioFormat::SetType(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechWaveFormatEx properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechWaveFormatEx operations

short ISpeechWaveFormatEx::GetFormatTag()
{
	short result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetFormatTag(short nNewValue)
{
	static BYTE parms[] =
		VTS_I2;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

short ISpeechWaveFormatEx::GetChannels()
{
	short result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetChannels(short nNewValue)
{
	static BYTE parms[] =
		VTS_I2;
	InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechWaveFormatEx::GetSamplesPerSec()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetSamplesPerSec(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechWaveFormatEx::GetAvgBytesPerSec()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetAvgBytesPerSec(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

short ISpeechWaveFormatEx::GetBlockAlign()
{
	short result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetBlockAlign(short nNewValue)
{
	static BYTE parms[] =
		VTS_I2;
	InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

short ISpeechWaveFormatEx::GetBitsPerSample()
{
	short result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetBitsPerSample(short nNewValue)
{
	static BYTE parms[] =
		VTS_I2;
	InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

VARIANT ISpeechWaveFormatEx::GetExtraData()
{
	VARIANT result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

void ISpeechWaveFormatEx::SetExtraData(const VARIANT& newValue)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 &newValue);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechBaseStream properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechBaseStream operations

LPDISPATCH ISpeechBaseStream::GetFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechBaseStream::SetRefFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechBaseStream::Read(VARIANT* Buffer, long NumberOfBytes)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Buffer, NumberOfBytes);
	return result;
}

long ISpeechBaseStream::Write(const VARIANT& Buffer)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&Buffer);
	return result;
}

VARIANT ISpeechBaseStream::Seek(const VARIANT& Position, long Origin)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Position, Origin);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechFileStream properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechFileStream operations

LPDISPATCH ISpeechFileStream::GetFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechFileStream::SetRefFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechFileStream::Read(VARIANT* Buffer, long NumberOfBytes)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Buffer, NumberOfBytes);
	return result;
}

long ISpeechFileStream::Write(const VARIANT& Buffer)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&Buffer);
	return result;
}

VARIANT ISpeechFileStream::Seek(const VARIANT& Position, long Origin)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Position, Origin);
	return result;
}

void ISpeechFileStream::Open(LPCTSTR FileName, long FileMode, BOOL DoEvents)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_BOOL;
	InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 FileName, FileMode, DoEvents);
}

void ISpeechFileStream::Close()
{
	InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechMemoryStream properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechMemoryStream operations

LPDISPATCH ISpeechMemoryStream::GetFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechMemoryStream::SetRefFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechMemoryStream::Read(VARIANT* Buffer, long NumberOfBytes)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Buffer, NumberOfBytes);
	return result;
}

long ISpeechMemoryStream::Write(const VARIANT& Buffer)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&Buffer);
	return result;
}

VARIANT ISpeechMemoryStream::Seek(const VARIANT& Position, long Origin)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Position, Origin);
	return result;
}

void ISpeechMemoryStream::SetData(const VARIANT& Data)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &Data);
}

VARIANT ISpeechMemoryStream::GetData()
{
	VARIANT result;
	InvokeHelper(0x65, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechCustomStream properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechCustomStream operations

LPDISPATCH ISpeechCustomStream::GetFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechCustomStream::SetRefFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechCustomStream::Read(VARIANT* Buffer, long NumberOfBytes)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Buffer, NumberOfBytes);
	return result;
}

long ISpeechCustomStream::Write(const VARIANT& Buffer)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&Buffer);
	return result;
}

VARIANT ISpeechCustomStream::Seek(const VARIANT& Position, long Origin)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Position, Origin);
	return result;
}

LPUNKNOWN ISpeechCustomStream::GetBaseStream()
{
	LPUNKNOWN result;
	InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
	return result;
}

void ISpeechCustomStream::SetRefBaseStream(LPUNKNOWN newValue)
{
	static BYTE parms[] =
		VTS_UNKNOWN;
	InvokeHelper(0x64, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechAudio properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechAudio operations

LPDISPATCH ISpeechAudio::GetFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechAudio::SetRefFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechAudio::Read(VARIANT* Buffer, long NumberOfBytes)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Buffer, NumberOfBytes);
	return result;
}

long ISpeechAudio::Write(const VARIANT& Buffer)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&Buffer);
	return result;
}

VARIANT ISpeechAudio::Seek(const VARIANT& Position, long Origin)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Position, Origin);
	return result;
}

LPDISPATCH ISpeechAudio::GetStatus()
{
	LPDISPATCH result;
	InvokeHelper(0xc8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechAudio::GetBufferInfo()
{
	LPDISPATCH result;
	InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechAudio::GetDefaultFormat()
{
	LPDISPATCH result;
	InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ISpeechAudio::GetVolume()
{
	long result;
	InvokeHelper(0xcb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechAudio::SetVolume(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xcb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechAudio::GetBufferNotifySize()
{
	long result;
	InvokeHelper(0xcc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechAudio::SetBufferNotifySize(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xcc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechMMSysAudio properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechMMSysAudio operations

LPDISPATCH ISpeechMMSysAudio::GetFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechMMSysAudio::SetRefFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechMMSysAudio::Read(VARIANT* Buffer, long NumberOfBytes)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_I4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Buffer, NumberOfBytes);
	return result;
}

long ISpeechMMSysAudio::Write(const VARIANT& Buffer)
{
	long result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		&Buffer);
	return result;
}

VARIANT ISpeechMMSysAudio::Seek(const VARIANT& Position, long Origin)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Position, Origin);
	return result;
}

LPDISPATCH ISpeechMMSysAudio::GetStatus()
{
	LPDISPATCH result;
	InvokeHelper(0xc8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechMMSysAudio::GetBufferInfo()
{
	LPDISPATCH result;
	InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechMMSysAudio::GetDefaultFormat()
{
	LPDISPATCH result;
	InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ISpeechMMSysAudio::GetVolume()
{
	long result;
	InvokeHelper(0xcb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechMMSysAudio::SetVolume(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xcb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechMMSysAudio::GetBufferNotifySize()
{
	long result;
	InvokeHelper(0xcc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechMMSysAudio::SetBufferNotifySize(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xcc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechMMSysAudio::GetDeviceId()
{
	long result;
	InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechMMSysAudio::SetDeviceId(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechMMSysAudio::GetLineId()
{
	long result;
	InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechMMSysAudio::SetLineId(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechVoice properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechVoice operations

LPDISPATCH ISpeechVoice::GetStatus()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechVoice::GetVoice()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetRefVoice(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x2, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechVoice::GetAudioOutput()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetRefAudioOutput(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechVoice::GetAudioOutputStream()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetRefAudioOutputStream(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

long ISpeechVoice::GetRate()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetRate(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechVoice::GetVolume()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetVolume(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechVoice::GetEventInterests()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetEventInterests(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

void ISpeechVoice::SetPriority(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechVoice::GetPriority()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetAlertBoundary(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechVoice::GetAlertBoundary()
{
	long result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechVoice::SetSynchronousSpeakTimeout(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechVoice::GetSynchronousSpeakTimeout()
{
	long result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoice::Speak(LPCTSTR Text, long Flags)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Text, Flags);
	return result;
}

long ISpeechVoice::SpeakStream(LPDISPATCH Stream, long Flags)
{
	long result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Stream, Flags);
	return result;
}

void ISpeechVoice::Pause()
{
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechVoice::Resume()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long ISpeechVoice::Skip(LPCTSTR Type, long NumItems)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Type, NumItems);
	return result;
}

LPDISPATCH ISpeechVoice::GetVoices(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}

LPDISPATCH ISpeechVoice::GetAudioOutputs(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}

BOOL ISpeechVoice::WaitUntilDone(long msTimeout)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		msTimeout);
	return result;
}

BOOL ISpeechVoice::IsUISupported(LPCTSTR TypeOfUI, VARIANT* ExtraData)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_PVARIANT;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		TypeOfUI, ExtraData);
	return result;
}

void ISpeechVoice::DisplayUI(long hWndParent, LPCTSTR Title, LPCTSTR TypeOfUI, VARIANT* ExtraData)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_PVARIANT;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hWndParent, Title, TypeOfUI, ExtraData);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechVoiceStatus properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechVoiceStatus operations

long ISpeechVoiceStatus::GetCurrentStreamNumber()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetLastStreamNumberQueued()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetLastHResult()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetRunningState()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetInputWordPosition()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetInputWordLength()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetInputSentencePosition()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechVoiceStatus::GetInputSentenceLength()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechVoiceStatus::GetLastBookmark()
{
	CString result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

short ISpeechVoiceStatus::GetPhonemeId()
{
	short result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
	return result;
}

short ISpeechVoiceStatus::GetVisemeId()
{
	short result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// _ISpeechVoiceEvents properties

/////////////////////////////////////////////////////////////////////////////
// _ISpeechVoiceEvents operations

void _ISpeechVoiceEvents::StartStream(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechVoiceEvents::EndStream(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechVoiceEvents::VoiceChange(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH VoiceObjectToken)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, VoiceObjectToken);
}

void _ISpeechVoiceEvents::Bookmark(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR Bookmark, long BookmarkId)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_BSTR VTS_I4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, Bookmark, BookmarkId);
}

void _ISpeechVoiceEvents::Word(long StreamNumber, const VARIANT& StreamPosition, long CharacterPosition, long Length)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4 VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, CharacterPosition, Length);
}

void _ISpeechVoiceEvents::Sentence(long StreamNumber, const VARIANT& StreamPosition, long CharacterPosition, long Length)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4 VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, CharacterPosition, Length);
}

void _ISpeechVoiceEvents::Phoneme(long StreamNumber, const VARIANT& StreamPosition, long Duration, short NextPhoneId, long Feature, short CurrentPhoneId)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4 VTS_I2 VTS_I4 VTS_I2;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, Duration, NextPhoneId, Feature, CurrentPhoneId);
}

void _ISpeechVoiceEvents::Viseme(long StreamNumber, const VARIANT& StreamPosition, long Duration, long NextVisemeId, long Feature, long CurrentVisemeId)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, Duration, NextVisemeId, Feature, CurrentVisemeId);
}

void _ISpeechVoiceEvents::AudioLevel(long StreamNumber, const VARIANT& StreamPosition, long AudioLevel)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, AudioLevel);
}

void _ISpeechVoiceEvents::EnginePrivate(long StreamNumber, long StreamPosition, const VARIANT& EngineData)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_VARIANT;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, StreamPosition, &EngineData);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizer properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizer operations

void ISpeechRecognizer::SetRefRecognizer(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecognizer::GetRecognizer()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecognizer::SetRefAudioInput(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecognizer::GetAudioInput()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecognizer::SetRefAudioInputStream(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecognizer::GetAudioInputStream()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL ISpeechRecognizer::GetIsShared()
{
	BOOL result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void ISpeechRecognizer::SetState(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecognizer::GetState()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecognizer::GetStatus()
{
	LPDISPATCH result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecognizer::SetRefProfile(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x8, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecognizer::GetProfile()
{
	LPDISPATCH result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecognizer::EmulateRecognition(const VARIANT& TextElements, VARIANT* ElementDisplayAttributes, long LanguageId)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_PVARIANT VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &TextElements, ElementDisplayAttributes, LanguageId);
}

LPDISPATCH ISpeechRecognizer::CreateRecoContext()
{
	LPDISPATCH result;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecognizer::GetFormat(long Type)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Type);
	return result;
}

BOOL ISpeechRecognizer::IsUISupported(LPCTSTR TypeOfUI, VARIANT* ExtraData)
{
	BOOL result;
	static BYTE parms[] =
		VTS_BSTR VTS_PVARIANT;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		TypeOfUI, ExtraData);
	return result;
}

void ISpeechRecognizer::DisplayUI(long hWndParent, LPCTSTR Title, LPCTSTR TypeOfUI, VARIANT* ExtraData)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BSTR VTS_PVARIANT;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hWndParent, Title, TypeOfUI, ExtraData);
}

LPDISPATCH ISpeechRecognizer::GetRecognizers(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}

LPDISPATCH ISpeechRecognizer::GetAudioInputs(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}

LPDISPATCH ISpeechRecognizer::GetProfiles(LPCTSTR RequiredAttributes, LPCTSTR OptionalAttributes)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequiredAttributes, OptionalAttributes);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizerStatus properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecognizerStatus operations

LPDISPATCH ISpeechRecognizerStatus::GetAudioStatus()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechRecognizerStatus::GetCurrentStreamPosition()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long ISpeechRecognizerStatus::GetCurrentStreamNumber()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechRecognizerStatus::GetNumberOfActiveRules()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechRecognizerStatus::GetClsidEngine()
{
	CString result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechRecognizerStatus::GetSupportedLanguages()
{
	VARIANT result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoContext properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoContext operations

LPDISPATCH ISpeechRecoContext::GetRecognizer()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ISpeechRecoContext::GetAudioInputInterferenceStatus()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechRecoContext::GetRequestedUIType()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetRefVoice(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecoContext::GetVoice()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetVoicePurgeEvent(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetVoicePurgeEvent()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetEventInterests(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetEventInterests()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetCmdMaxAlternates(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetCmdMaxAlternates()
{
	long result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetState(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetState()
{
	long result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetRetainedAudio(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoContext::GetRetainedAudio()
{
	long result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::SetRefRetainedAudioFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0xb, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecoContext::GetRetainedAudioFormat()
{
	LPDISPATCH result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoContext::Pause()
{
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechRecoContext::Resume()
{
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISpeechRecoContext::CreateGrammar(const VARIANT& GrammarId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&GrammarId);
	return result;
}

LPDISPATCH ISpeechRecoContext::CreateResultFromMemory(VARIANT* ResultBlock)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_PVARIANT;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ResultBlock);
	return result;
}

void ISpeechRecoContext::Bookmark(long Options, const VARIANT& StreamPos, const VARIANT& BookmarkId)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Options, &StreamPos, &BookmarkId);
}

void ISpeechRecoContext::SetAdaptationData(LPCTSTR AdaptationString)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AdaptationString);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoGrammar properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoGrammar operations

VARIANT ISpeechRecoGrammar::GetId()
{
	VARIANT result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoGrammar::GetRecoContext()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoGrammar::SetState(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechRecoGrammar::GetState()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoGrammar::GetRules()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoGrammar::Reset(long NewLanguage)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 NewLanguage);
}

void ISpeechRecoGrammar::CmdLoadFromFile(LPCTSTR FileName, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 FileName, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromObject(LPCTSTR ClassId, LPCTSTR GrammarName, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_I4;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ClassId, GrammarName, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromResource(long hModule, const VARIANT& ResourceName, const VARIANT& ResourceType, long LanguageId, long LoadOption)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hModule, &ResourceName, &ResourceType, LanguageId, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromMemory(const VARIANT& GrammarData, long LoadOption)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_I4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &GrammarData, LoadOption);
}

void ISpeechRecoGrammar::CmdLoadFromProprietaryGrammar(LPCTSTR ProprietaryGuid, LPCTSTR ProprietaryString, const VARIANT& ProprietaryData, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_VARIANT VTS_I4;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ProprietaryGuid, ProprietaryString, &ProprietaryData, LoadOption);
}

void ISpeechRecoGrammar::CmdSetRuleState(LPCTSTR Name, long State)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Name, State);
}

void ISpeechRecoGrammar::CmdSetRuleIdState(long RuleId, long State)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 RuleId, State);
}

void ISpeechRecoGrammar::DictationLoad(LPCTSTR TopicName, long LoadOption)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 TopicName, LoadOption);
}

void ISpeechRecoGrammar::DictationUnload()
{
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechRecoGrammar::DictationSetState(long State)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 State);
}

void ISpeechRecoGrammar::SetWordSequenceData(LPCTSTR Text, long TextLength, LPDISPATCH Info)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_DISPATCH;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Text, TextLength, Info);
}

void ISpeechRecoGrammar::SetTextSelection(LPDISPATCH Info)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Info);
}

long ISpeechRecoGrammar::IsPronounceable(LPCTSTR Word)
{
	long result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		Word);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRules properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRules operations

long ISpeechGrammarRules::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRules::FindRule(const VARIANT& RuleNameOrId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&RuleNameOrId);
	return result;
}

LPDISPATCH ISpeechGrammarRules::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}

BOOL ISpeechGrammarRules::GetDynamic()
{
	BOOL result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRules::Add(LPCTSTR RuleName, long Attributes, long RuleId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RuleName, Attributes, RuleId);
	return result;
}

void ISpeechGrammarRules::Commit()
{
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

VARIANT ISpeechGrammarRules::CommitAndSave(BSTR* ErrorText)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_PBSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		ErrorText);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRule properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRule operations

long ISpeechGrammarRule::GetAttributes()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRule::GetInitialState()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString ISpeechGrammarRule::GetName()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long ISpeechGrammarRule::GetId()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechGrammarRule::Clear()
{
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISpeechGrammarRule::AddResource(LPCTSTR ResourceName, LPCTSTR ResourceValue)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ResourceName, ResourceValue);
}

LPDISPATCH ISpeechGrammarRule::AddState()
{
	LPDISPATCH result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleState properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleState operations

LPDISPATCH ISpeechGrammarRuleState::GetRule()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRuleState::GetTransitions()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechGrammarRuleState::AddWordTransition(LPDISPATCH DestState, LPCTSTR Words, LPCTSTR Separators, long Type, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_BSTR VTS_BSTR VTS_I4 VTS_BSTR VTS_I4 VTS_PVARIANT VTS_R4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 DestState, Words, Separators, Type, PropertyName, PropertyId, PropertyValue, Weight);
}

void ISpeechGrammarRuleState::AddRuleTransition(LPDISPATCH DestinationState, LPDISPATCH Rule, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_BSTR VTS_I4 VTS_PVARIANT VTS_R4;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 DestinationState, Rule, PropertyName, PropertyId, PropertyValue, Weight);
}

void ISpeechGrammarRuleState::AddSpecialTransition(LPDISPATCH DestinationState, long Type, LPCTSTR PropertyName, long PropertyId, VARIANT* PropertyValue, float Weight)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I4 VTS_BSTR VTS_I4 VTS_PVARIANT VTS_R4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 DestinationState, Type, PropertyName, PropertyId, PropertyValue, Weight);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransitions properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransitions operations

long ISpeechGrammarRuleStateTransitions::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRuleStateTransitions::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransition properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechGrammarRuleStateTransition operations

long ISpeechGrammarRuleStateTransition::GetType()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechGrammarRuleStateTransition::GetText()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRuleStateTransition::GetRule()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechGrammarRuleStateTransition::GetWeight()
{
	VARIANT result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

CString ISpeechGrammarRuleStateTransition::GetPropertyName()
{
	CString result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long ISpeechGrammarRuleStateTransition::GetPropertyId()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechGrammarRuleStateTransition::GetPropertyValue()
{
	VARIANT result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechGrammarRuleStateTransition::GetNextState()
{
	LPDISPATCH result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechTextSelectionInformation properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechTextSelectionInformation operations

void ISpeechTextSelectionInformation::SetActiveOffset(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechTextSelectionInformation::GetActiveOffset()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechTextSelectionInformation::SetActiveLength(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechTextSelectionInformation::GetActiveLength()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechTextSelectionInformation::SetSelectionOffset(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechTextSelectionInformation::GetSelectionOffset()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechTextSelectionInformation::SetSelectionLength(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long ISpeechTextSelectionInformation::GetSelectionLength()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResult properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResult operations

LPDISPATCH ISpeechRecoResult::GetRecoContext()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoResult::GetTimes()
{
	LPDISPATCH result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechRecoResult::SetRefAudioFormat(LPDISPATCH newValue)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
		 newValue);
}

LPDISPATCH ISpeechRecoResult::GetAudioFormat()
{
	LPDISPATCH result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoResult::GetPhraseInfo()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechRecoResult::Alternates(long RequestCount, long StartElement, long Elements)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		RequestCount, StartElement, Elements);
	return result;
}

LPDISPATCH ISpeechRecoResult::Audio(long StartElement, long Elements)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		StartElement, Elements);
	return result;
}

long ISpeechRecoResult::SpeakAudio(long StartElement, long Elements, long Flags)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		StartElement, Elements, Flags);
	return result;
}

VARIANT ISpeechRecoResult::SaveToMemory()
{
	VARIANT result;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

void ISpeechRecoResult::DiscardResultInfo(long ValueTypes)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ValueTypes);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResultTimes properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechRecoResultTimes operations

VARIANT ISpeechRecoResultTimes::GetStreamTime()
{
	VARIANT result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechRecoResultTimes::GetLength()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long ISpeechRecoResultTimes::GetTickCount()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechRecoResultTimes::GetOffsetFromStart()
{
	VARIANT result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfo properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfo operations

long ISpeechPhraseInfo::GetLanguageId()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseInfo::GetGrammarId()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseInfo::GetStartTime()
{
	VARIANT result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseInfo::GetAudioStreamPosition()
{
	VARIANT result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseInfo::GetAudioSizeBytes()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseInfo::GetRetainedSizeBytes()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseInfo::GetAudioSizeTime()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseInfo::GetRule()
{
	LPDISPATCH result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseInfo::GetProperties()
{
	LPDISPATCH result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseInfo::GetElements()
{
	LPDISPATCH result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseInfo::GetReplacements()
{
	LPDISPATCH result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

CString ISpeechPhraseInfo::GetEngineId()
{
	CString result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseInfo::GetEnginePrivateData()
{
	VARIANT result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseInfo::SaveToMemory()
{
	VARIANT result;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

CString ISpeechPhraseInfo::GetText(long StartElement, long Elements, BOOL UseReplacements)
{
	CString result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_BOOL;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		StartElement, Elements, UseReplacements);
	return result;
}

long ISpeechPhraseInfo::GetDisplayAttributes(long StartElement, long Elements, BOOL UseReplacements)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_BOOL;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		StartElement, Elements, UseReplacements);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseRule properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseRule operations

CString ISpeechPhraseRule::GetName()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseRule::GetId()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseRule::GetFirstElement()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseRule::GetNumberOfElements()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseRule::GetParent()
{
	LPDISPATCH result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseRule::GetChildren()
{
	LPDISPATCH result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseRule::GetConfidence()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

float ISpeechPhraseRule::GetEngineConfidence()
{
	float result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseRules properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseRules operations

long ISpeechPhraseRules::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseRules::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseProperties properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseProperties operations

long ISpeechPhraseProperties::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseProperties::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseProperty properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseProperty operations

CString ISpeechPhraseProperty::GetName()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseProperty::GetId()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseProperty::GetValue()
{
	VARIANT result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseProperty::GetFirstElement()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseProperty::GetNumberOfElements()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

float ISpeechPhraseProperty::GetEngineConfidence()
{
	float result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseProperty::GetConfidence()
{
	long result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseProperty::GetParent()
{
	LPDISPATCH result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseProperty::GetChildren()
{
	LPDISPATCH result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseElements properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseElements operations

long ISpeechPhraseElements::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseElements::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseElement properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseElement operations

long ISpeechPhraseElement::GetAudioTimeOffset()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetAudioSizeTime()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetAudioStreamOffset()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetAudioSizeBytes()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetRetainedStreamOffset()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetRetainedSizeBytes()
{
	long result;
	InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechPhraseElement::GetDisplayText()
{
	CString result;
	InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString ISpeechPhraseElement::GetLexicalForm()
{
	CString result;
	InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechPhraseElement::GetPronunciation()
{
	VARIANT result;
	InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetDisplayAttributes()
{
	long result;
	InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetRequiredConfidence()
{
	long result;
	InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseElement::GetActualConfidence()
{
	long result;
	InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

float ISpeechPhraseElement::GetEngineConfidence()
{
	float result;
	InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseReplacements properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseReplacements operations

long ISpeechPhraseReplacements::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseReplacements::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseReplacement properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseReplacement operations

long ISpeechPhraseReplacement::GetDisplayAttributes()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechPhraseReplacement::GetText()
{
	CString result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseReplacement::GetFirstElement()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseReplacement::GetNumberOfElements()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseAlternates properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseAlternates operations

long ISpeechPhraseAlternates::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseAlternates::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseAlternate properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseAlternate operations

LPDISPATCH ISpeechPhraseAlternate::GetRecoResult()
{
	LPDISPATCH result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseAlternate::GetStartElementInResult()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechPhraseAlternate::GetNumberOfElementsInResult()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechPhraseAlternate::GetPhraseInfo()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void ISpeechPhraseAlternate::Commit()
{
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// _ISpeechRecoContextEvents properties

/////////////////////////////////////////////////////////////////////////////
// _ISpeechRecoContextEvents operations

void _ISpeechRecoContextEvents::StartStream(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechRecoContextEvents::EndStream(long StreamNumber, const VARIANT& StreamPosition, BOOL StreamReleased)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_BOOL;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, StreamReleased);
}

void _ISpeechRecoContextEvents::Bookmark(long StreamNumber, const VARIANT& StreamPosition, const VARIANT& BookmarkId, long Options)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, &BookmarkId, Options);
}

void _ISpeechRecoContextEvents::SoundStart(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechRecoContextEvents::SoundEnd(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechRecoContextEvents::PhraseStart(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechRecoContextEvents::Recognition(long StreamNumber, const VARIANT& StreamPosition, long RecognitionType, LPDISPATCH Result)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4 VTS_DISPATCH;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, RecognitionType, Result);
}

void _ISpeechRecoContextEvents::Hypothesis(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH Result)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_DISPATCH;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, Result);
}

void _ISpeechRecoContextEvents::PropertyNumberChange(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR PropertyName, long NewNumberValue)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_BSTR VTS_I4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, PropertyName, NewNumberValue);
}

void _ISpeechRecoContextEvents::PropertyStringChange(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR PropertyName, LPCTSTR NewStringValue)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_BSTR VTS_BSTR;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, PropertyName, NewStringValue);
}

void _ISpeechRecoContextEvents::FalseRecognition(long StreamNumber, const VARIANT& StreamPosition, LPDISPATCH Result)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_DISPATCH;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, Result);
}

void _ISpeechRecoContextEvents::Interference(long StreamNumber, const VARIANT& StreamPosition, long Interference)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, Interference);
}

void _ISpeechRecoContextEvents::RequestUI(long StreamNumber, const VARIANT& StreamPosition, LPCTSTR UIType)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_BSTR;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, UIType);
}

void _ISpeechRecoContextEvents::RecognizerStateChange(long StreamNumber, const VARIANT& StreamPosition, long NewState)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, NewState);
}

void _ISpeechRecoContextEvents::Adaptation(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechRecoContextEvents::RecognitionForOtherContext(long StreamNumber, const VARIANT& StreamPosition)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition);
}

void _ISpeechRecoContextEvents::AudioLevel(long StreamNumber, const VARIANT& StreamPosition, long AudioLevel)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_I4;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, AudioLevel);
}

void _ISpeechRecoContextEvents::EnginePrivate(long StreamNumber, const VARIANT& StreamPosition, const VARIANT& EngineData)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 StreamNumber, &StreamPosition, &EngineData);
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechLexicon properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechLexicon operations

LPDISPATCH ISpeechLexicon::GetWords(long Flags, long* GenerationId)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Flags, GenerationId);
	return result;
}

void ISpeechLexicon::AddPronunciation(LPCTSTR bstrWord, long LangId, long PartOfSpeech, LPCTSTR bstrPronunciation)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4 VTS_BSTR;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 bstrWord, LangId, PartOfSpeech, bstrPronunciation);
}

void ISpeechLexicon::RemovePronunciation(LPCTSTR bstrWord, long LangId, long PartOfSpeech, LPCTSTR bstrPronunciation)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4 VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 bstrWord, LangId, PartOfSpeech, bstrPronunciation);
}

LPDISPATCH ISpeechLexicon::GetPronunciations(LPCTSTR bstrWord, long LangId, long TypeFlags)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_I4;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		bstrWord, LangId, TypeFlags);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconWords properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconWords operations

long ISpeechLexiconWords::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechLexiconWords::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconWord properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconWord operations

long ISpeechLexiconWord::GetLangId()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechLexiconWord::GetType()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

CString ISpeechLexiconWord::GetWord()
{
	CString result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechLexiconWord::GetPronunciations()
{
	LPDISPATCH result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconPronunciations properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconPronunciations operations

long ISpeechLexiconPronunciations::GetCount()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH ISpeechLexiconPronunciations::Item(long Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconPronunciation properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechLexiconPronunciation operations

long ISpeechLexiconPronunciation::GetType()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechLexiconPronunciation::GetLangId()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

long ISpeechLexiconPronunciation::GetPartOfSpeech()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

VARIANT ISpeechLexiconPronunciation::GetPhoneIds()
{
	VARIANT result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

CString ISpeechLexiconPronunciation::GetSymbolic()
{
	CString result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfoBuilder properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhraseInfoBuilder operations

LPDISPATCH ISpeechPhraseInfoBuilder::RestorePhraseFromMemory(VARIANT* PhraseInMemory)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_PVARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		PhraseInMemory);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISpeechPhoneConverter properties

/////////////////////////////////////////////////////////////////////////////
// ISpeechPhoneConverter operations

long ISpeechPhoneConverter::GetLanguageId()
{
	long result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void ISpeechPhoneConverter::SetLanguageId(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

VARIANT ISpeechPhoneConverter::PhoneToId(LPCTSTR Phonemes)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		Phonemes);
	return result;
}

CString ISpeechPhoneConverter::IdToPhone(const VARIANT& IdArray)
{
	CString result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
		&IdArray);
	return result;
}
